﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SQLite;
using System.IO;
using System.Linq;

namespace DataAchive.Helper
{
    /// <summary>
    /// 数据访问基础类(基于SQLite)
    /// 可以用户可以修改满足自己项目的需要。
    /// </summary>
    public abstract class DbHelperSQLite
    {
        private string DBName;
        protected string connectionString;


        public DbHelperSQLite()
        {
            DateTime dateTime = DateTime.Now;
            DBName = GetDBName();
            //DBName = GetDBName(dateTime);
            //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
            connectionString = CreateConnectionString();
            //connectionString = CreateConnectionString(dateTime);
        }

        public DbHelperSQLite(DateTime dateTime)
        {
            DBName = GetDBName();
            //DBName = GetDBName(dateTime);
            connectionString = CreateConnectionString();
            //connectionString = CreateConnectionString(dateTime);
        }

        public string GetDBName()
        {
            //var settingDBName = Setting.GetElementTextValue("SQLiteDB").Split('.');
            //DBName = $"{settingDBName.First()}-{DateTime.Now.Day}.{settingDBName.Last()}";
            //return DBName;
            return Setting.GetElementTextValue("SQLiteDB");
        }

        private string CreateConnectionString()
        {
            string sqlLitePath = $@"data source={System.Environment.CurrentDirectory}\DB\{DBName};version=3;";
            return sqlLitePath;
        }


        public string GetDBName(DateTime dateTime)
        {
            var settingDBName = Setting.GetElementTextValue("SQLiteDB").Split('.');
            DBName = $"{settingDBName.First()}-{dateTime.Month}.{settingDBName.Last()}";
            //return DBName;
            return Setting.GetElementTextValue("SQLiteDB");
        }
        private string CreateConnectionString(DateTime dateTime)
        {
            var settingDBName = Setting.GetElementTextValue("SQLiteDB").Split('.');
            DBName = $"{settingDBName.First()}-{dateTime.Month}.{settingDBName.Last()}";
            string path = $@"{System.Environment.CurrentDirectory}\DB\{dateTime.Year}\{DBName}";
            string sqlLitePath = $@"data source={path};version=3;";
            return sqlLitePath;
        }

        public void SetTable()
        {
            SoftCommon.Log.Write($"初始化数据库连接，如果数据库和表不存在，创建文件！");
            // 检查文件夹是否存在，不存在则创建
            string path = System.Environment.CurrentDirectory + $@"\DB\{DateTime.Now.Year}";
            //string path = System.Environment.CurrentDirectory + $@"\DB";
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            // 检查数据库文件是否存在，如果不存在则创建新的数据库文件
            string dbName = path + $@"\{DBName}";
            if (!File.Exists(dbName))
            {
                SQLiteConnection.CreateFile(dbName);
            }

            string tableInfo = @"
                    CREATE TABLE IF NOT EXISTS info (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        classify TEXT,
                        px REAL,
                        py REAL,
                        width REAL,
                        height REAL,
                        ngId INTEGER,
                        creator TEXT,
                        celllocation TEXT,
                        FOREIGN KEY(ngId) REFERENCES info(id)
                    );";
            string tableNG = @"
                    CREATE TABLE IF NOT EXISTS ng (
                        lotid TEXT NOT NULL,
                        info TEXT,
                        image TEXT,
                        _checked INT DEFAULT 0,
                        date DATETIME DEFAULT CURRENT_TIMESTAMP,
                        type INT DEFAULT 0,
                        aiinfo TEXT,
                        id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                        site_id INTEGER,
                        finishtime DATETIME DEFAULT CURRENT_TIMESTAMP,
                        airesult TEXT,
                        manualresult TEXT,
                        mes_check INT DEFAULT 0,
                        FOREIGN KEY(site_id) REFERENCES info(id)
                    );";
            string tableSite = @"
                    CREATE TABLE IF NOT EXISTS site (
                        id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                        line_id TEXT,
                        equipment_id TEXT,
                        ip TEXT,
                        row_number INT,
                        row_type INT,
                        row_order TEXT,
                        column_number INT,
                        column_type INT,
                        column_order TEXT,
                        top_bottom_margin INT,
                        left_right_margin INT,
                        shift_start_time TEXT,
                        shiftings INT,
                        currentshift INT
                    );";
            string sql = tableInfo + tableNG + tableSite;
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                try
                {
                    connection.Open();
                    using (SQLiteCommand command = new SQLiteCommand(sql, connection))
                    {
                        command.ExecuteNonQuery();
                    }
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    connection.Close();
                    SoftCommon.Log.Write($"SQL异常：{E.Message}");
                }


            }
        }


        #region 原始helper

        #region 公用方法

        public abstract int GetMaxID(string FieldName, string TableName);
        public abstract bool Exists(string strSql);
        public abstract bool Exists(string strSql, params SQLiteParameter[] cmdParms);

        #endregion

        #region  执行简单SQL语句


        /// <summary>
        /// 插入一条sql，返回id
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public abstract int InsertGetId(string SQLString);

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public abstract int ExecuteSql(string SQLString);

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param>
        public abstract void ExecuteSqlTran(ArrayList SQLStringList);

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public abstract int ExecuteSql(string SQLString, string content);
        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public abstract int ExecuteSqlInsertImg(string strSQL, byte[] fs);

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public abstract object GetSingle(string SQLString);
        /// <summary>
        /// 执行查询语句，返回SQLiteDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SQLiteDataReader</returns>
        public abstract SQLiteDataReader ExecuteReader(string strSQL);
        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public abstract DataSet Query(string SQLString);


        #endregion

        #region 执行带参数的SQL语句
        /// <summary>
        /// 执行SQL语句，返回新增ID
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public abstract int ExecuteSql(string SQLString, params SQLiteParameter[] cmdParms);
        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public abstract int InsertGetId(string SQLString, params SQLiteParameter[] cmdParms);

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SQLiteParameter[]）</param>
        public abstract void ExecuteSqlTran(Hashtable SQLStringList);


        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public abstract object GetSingle(string SQLString, params SQLiteParameter[] cmdParms);

        /// <summary>
        /// 执行查询语句，返回SQLiteDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SQLiteDataReader</returns>
        public abstract SQLiteDataReader ExecuteReader(string SQLString, params SQLiteParameter[] cmdParms);

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public abstract DataSet Query(string SQLString, params SQLiteParameter[] cmdParms);


        #endregion

        /// <summary>
        /// 批量处理数据操作语句。
        /// </summary>
        /// <param name="list">SQL语句集合。</param>
        /// <exception cref="Exception"></exception>
        public abstract void ExecuteNonQueryBatch(List<KeyValuePair<string, SQLiteParameter[]>> list);
        #endregion
    }


    //public class SQLiteHelper
    //{
    //    public SQLiteHelper()
    //    {
    //        SetConnectionString("TestDB.db", "");
    //    }

    //    private string connectionString = string.Empty;

    //    /// <summary>
    //    /// 根据数据源、密码、版本号设置连接字符串。
    //    /// </summary>
    //    /// <param name="datasource">数据源。</param>
    //    /// <param name="password">密码。</param>
    //    /// <param name="version">版本号（缺省为3）。</param>
    //    public void SetConnectionString(string datasource, string password, int version = 3)
    //    {
    //        connectionString = string.Format("Data Source={0};Version={1};password={2}",
    //            datasource, version, password);
    //    }


    //    /// <summary>
    //    /// 创建一个数据库文件。如果存在同名数据库文件，则会覆盖。
    //    /// </summary>
    //    /// <param name="dbName">数据库文件名。为null或空串时不创建。</param>
    //    /// <param name="password">（可选）数据库密码，默认为空。</param>
    //    /// <exception cref="Exception"></exception>
    //    public void CreateDB(string dbName)
    //    {
    //        if (!string.IsNullOrEmpty(dbName))
    //        {
    //            try { SQLiteConnection.CreateFile(dbName); }
    //            catch (Exception) { throw; }
    //        }
    //    }

    //    /// <summary> 
    //    /// 对SQLite数据库执行增删改操作，返回受影响的行数。 
    //    /// </summary> 
    //    /// <param name="sql">要执行的增删改的SQL语句。</param> 
    //    /// <param name="parameters">执行增删改语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param> 
    //    /// <returns></returns> 
    //    /// <exception cref="Exception"></exception>
    //    public int ExecuteNonQuery(string sql, params SQLiteParameter[] parameters)
    //    {
    //        int affectedRows = 0;
    //        using (SQLiteConnection connection = new SQLiteConnection(connectionString))
    //        {
    //            using (SQLiteCommand command = new SQLiteCommand(connection))
    //            {
    //                try
    //                {
    //                    connection.Open();
    //                    command.CommandText = sql;
    //                    if (parameters.Length != 0)
    //                    {
    //                        command.Parameters.AddRange(parameters);
    //                    }
    //                    affectedRows = command.ExecuteNonQuery();
    //                }
    //                catch (Exception) { throw; }
    //            }
    //        }
    //        return affectedRows;
    //    }

    //    /// <summary>
    //    /// 批量处理数据操作语句。
    //    /// </summary>
    //    /// <param name="list">SQL语句集合。</param>
    //    /// <exception cref="Exception"></exception>
    //    public void ExecuteNonQueryBatch(List<KeyValuePair<string, SQLiteParameter[]>> list)
    //    {
    //        using (SQLiteConnection conn = new SQLiteConnection(connectionString))
    //        {
    //            try { conn.Open(); }
    //            catch { throw; }
    //            using (SQLiteTransaction tran = conn.BeginTransaction())
    //            {
    //                using (SQLiteCommand cmd = new SQLiteCommand(conn))
    //                {
    //                    try
    //                    {
    //                        foreach (var item in list)
    //                        {
    //                            cmd.CommandText = item.Key;
    //                            if (item.Value != null)
    //                            {
    //                                cmd.Parameters.AddRange(item.Value);
    //                            }
    //                            cmd.ExecuteNonQuery();
    //                        }
    //                        tran.Commit();
    //                    }
    //                    catch (Exception) { tran.Rollback(); throw; }
    //                }
    //            }
    //        }
    //    }

    //    /// <summary>
    //    /// 执行查询语句，并返回第一个结果。
    //    /// </summary>
    //    /// <param name="sql">查询语句。</param>
    //    /// <returns>查询结果。</returns>
    //    /// <exception cref="Exception"></exception>
    //    public object ExecuteScalar(string sql, params SQLiteParameter[] parameters)
    //    {
    //        using (SQLiteConnection conn = new SQLiteConnection(connectionString))
    //        {
    //            using (SQLiteCommand cmd = new SQLiteCommand(conn))
    //            {
    //                try
    //                {
    //                    conn.Open();
    //                    cmd.CommandText = sql;
    //                    if (parameters.Length != 0)
    //                    {
    //                        cmd.Parameters.AddRange(parameters);
    //                    }
    //                    return cmd.ExecuteScalar();
    //                }
    //                catch (Exception) { throw; }
    //            }
    //        }
    //    }

    //    /// <summary> 
    //    /// 执行一个查询语句，返回一个包含查询结果的DataTable。 
    //    /// </summary> 
    //    /// <param name="sql">要执行的查询语句。</param> 
    //    /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param> 
    //    /// <returns></returns> 
    //    /// <exception cref="Exception"></exception>
    //    public DataTable ExecuteQuery(string sql, params SQLiteParameter[] parameters)
    //    {
    //        using (SQLiteConnection connection = new SQLiteConnection(connectionString))
    //        {
    //            using (SQLiteCommand command = new SQLiteCommand(sql, connection))
    //            {
    //                if (parameters.Length != 0)
    //                {
    //                    command.Parameters.AddRange(parameters);
    //                }
    //                SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
    //                DataTable data = new DataTable();
    //                try { adapter.Fill(data); }
    //                catch (Exception) { throw; }
    //                return data;
    //            }
    //        }
    //    }

    //    /// <summary> 
    //    /// 执行一个查询语句，返回一个关联的SQLiteDataReader实例。 
    //    /// </summary> 
    //    /// <param name="sql">要执行的查询语句。</param> 
    //    /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param> 
    //    /// <returns></returns> 
    //    /// <exception cref="Exception"></exception>
    //    public SQLiteDataReader ExecuteReader(string sql, params SQLiteParameter[] parameters)
    //    {
    //        SQLiteConnection connection = new SQLiteConnection(connectionString);
    //        SQLiteCommand command = new SQLiteCommand(sql, connection);
    //        try
    //        {
    //            if (parameters.Length != 0)
    //            {
    //                command.Parameters.AddRange(parameters);
    //            }
    //            connection.Open();
    //            return command.ExecuteReader(CommandBehavior.CloseConnection);
    //        }
    //        catch (Exception) { throw; }
    //    }

    //    /// <summary> 
    //    /// 查询数据库中的所有数据类型信息。
    //    /// </summary> 
    //    /// <returns></returns> 
    //    /// <exception cref="Exception"></exception>
    //    public DataTable GetSchema()
    //    {
    //        using (SQLiteConnection connection = new SQLiteConnection(connectionString))
    //        {
    //            try
    //            {
    //                connection.Open();
    //                return connection.GetSchema("TABLES");
    //            }
    //            catch (Exception) { throw; }
    //        }
    //    }

    //    //public Test GetList()
    //    //{
    //    //    ExecuteReader("", new SQLiteParameter[] { });
    //    //}


    //}


}
